/*
 * 文件名称:          AbstractBaseService.java
 * 版权所有@ 2016——2017 无锡聆音科技有限公司，保留所有权利
 * 时间:             2016年7月27日 下午9:21:11
 */

package com.lingyin.database.transaction.service;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;

import org.springframework.transaction.annotation.Transactional;

import com.lingyin.database.transaction.dao.BaseDao;
import com.lingyin.database.transaction.domain.BaseException;
import com.lingyin.database.transaction.domain.DataPage;

/**
 *  基本的对象创建、更新及删除处理
 * 
 * @项目        hibernate.database.transaction
 * 
 * @作者:       关宏新
 * 
 * @日期:       2016年7月27日
 * 
 * @负责人:    关宏新
 * 
 * @负责小组:   聆音项目组
 * 
 */
public abstract class AbstractBaseService<T> implements IBaseService<T>
{

    /**
     * 
     */
    public AbstractBaseService()
    {
    }

    /**
     * 
     * @return 返回任何一个base到对象
     */
    public abstract BaseDao<T> getBaseDao();

    /**
     * 保存对象
     * @param entity 保存的对象
     * @return T 保存的对象
     */
    @Transactional
    public T save(T entity)
    {
        return getBaseDao().save(entity);
    }

    /**
     * 保存集合中的所有对象
     * @param entities 保存的对象集合
     */
    @Transactional
    public void saveAll(final Collection<T> entities)
    {
        getBaseDao().saveAll(entities);
    }

    /**
     * 保存或更新对象
     * @param entity 更新的对象
     * @return T 更新的对象
     */
    @Transactional
    public T saveOrUpdateEntity(final T entity)
    {
        return getBaseDao().saveOrUpdateEntity(entity);
    }

    /**
     * 更新对象
     * @param entity 更新的对象
     * @return T 更新的对象
     */
    @Transactional
    public T update(final T entity)
    {
        return getBaseDao().update(entity);
    }

    /**
     * 更新对象
     * @param entity 更新的对象
     * @return T 更新的对象
     */
    @Transactional
    public T updateOne(final T entity)
    {
        return getBaseDao().updateOne(entity);
    }

    /**
     * 更新集合中的所有对象
     * @param entities 保存的对象集合
     */
    @Transactional
    public void updateAll(final Collection<T> entities)
    {
        getBaseDao().updateAll(entities);
    }

    /**
     * 删除对象
     * @param entity 删除的对象
     */
    @Transactional
    public void delete(T entity)
    {
        getBaseDao().delete(entity);
    }

    /**
     * 删除对象
     * @param entity 删除的对象
     */
    @Transactional
    public void deleteOne(T entity)
    {
        getBaseDao().deleteOne(entity);
    }

    /**
     * 删除集合中所有对象
     * @param entities
     */
    @Transactional
    public void deleteAll(Collection<T> entities)
    {
        getBaseDao().deleteAll(entities);
    }
    
    /**
     * 删除entityclass实例，idName为该实例的主键名
     * @param entityClass 实例类
     * @param idName 实例类的主键名，该名为对象中定义的主键名，不是数据库表的主键字段
     * @param ids 具体的主键值
     * @return Object 删除结果
     */
    @Transactional
    public Object deleteEntityByID(Class<?> entityClass, String idName, Serializable ... ids)
    {
        return getBaseDao().deleteEntityByID(entityClass, idName, ids);
    }
    
    /**
     * 通过主键查找该类的对象
     * @param entityClass 对象class
     * @param value 变量值
     * @return T 查询的对象
     */
    @Transactional(readOnly = true)
    public T findByKey(Class<T> entityClass, Serializable value)
    {
        return getBaseDao().findByKey(entityClass, value);
    }
    
    /**
     * 获得某个实例的记录总数。
     * @param clazz 实例的class对象
     * @return long 对象数量
     * @throws BaseException 封装后的异常。
     */
    @Transactional(readOnly = true)
    public long getCount(final Class<?> clazz)
    {
        return getBaseDao().getCount(clazz);
    }
    
    /**
     * 通过某个变量值查找该类的一定数量的对象
     * @param entityClass 对象class
     * @param start 获取对象的开始位置，如果小于等于0，则表示从第一个记录开始获取。
     * @param count 获取对象的数量，如果小于等于0，则表示从start位置开始获取后续所有对象。
     * @return List<T> 结果值
     */
    @Transactional(readOnly = true)
    public List<T> findPage(Class<T> entityClass, int start, int count)
    {
        return getBaseDao().findPage(entityClass, start, count);
    }
    
    /**
     * 通过某个变量值查找该类的所有数量的对象
     * @param entityClass 对象class
     * @return List<T> 结果值
     */
    @Transactional(readOnly = true)
    public List<T> findAll(Class<T> entityClass)
    {
        return getBaseDao().findPage(entityClass, -1, -1);
    }
    
    /**
     * 通过某个变量值查找该类的所有对象
     * @param entityClass 对象class
     * @param propertyName 对象的属性定义名
     * @param value 变量值
     * @return List<T> 结果值
     */
    @Transactional(readOnly = true)
    public List<T> findByProperty(Class<T> entityClass, String propertyName, Object value)
    {
        return getBaseDao().findByProperty(entityClass, propertyName, value);
    }
    
    /**
     * 通过某个变量值查找该类的一定数量的对象
     * @param entityClass 对象class
     * @param page 分页对象，该对象的值具体参见DataPage定义要求。
     * @return DataPage 分页结果值
     */
    @Transactional(readOnly = true)
    public DataPage<T> findPage(Class<T> entityClass, DataPage<T> page)
    {
        return getBaseDao().findPage(entityClass, page);
    }

}
